Application context migration framework and protocol

ABSTRACT

Embodiments described herein relate generally to the migration of a static object, such as an electronic document, across separate computer systems while retaining context data associated with the static object. In one embodiment, a source computer system is adapted to package a static object and associated context information and transmit the package over a network to a target computer system. The target computer system may present the static object in an application with the associated context information to substantially approximate presentation of the same at the source computer system. Other embodiments may be described and claimed.

CROSS REFERENCE TO RELATED APPLICATIONS

This application claims priority under 35 U.S.C. §119(e) to U.S. Provisional Patent Application No. 61/883,127 entitled “ADVANCED WIRELESS COMMUNICATION SYSTEMS AND TECHNIQUES,” filed Sep. 26, 2013, the disclosure of which is incorporated herein by reference.

FIELD OF INVENTION

Embodiments of the present invention relate generally to the technical field of data processing, and more particularly, to computer systems adapted to operate to communicate data over networks.

BACKGROUND

The background description provided herein is for the purpose of generally presenting the context of the disclosure. Work of the presently named inventors, to the extent it is described in this background section, as well as aspects of the description that may not otherwise qualify as prior art at the time of filing, are neither expressly nor impliedly admitted as prior art against the present disclosure. Unless otherwise indicated herein, the approaches described in this section are not prior art to the claims in the present disclosure and are not admitted to be prior art by the inclusion in this section.

Computer systems are generally adapted to execute a plurality of applications. These applications may be adapted to present a digital file to a user. Illustratively, a word processing application may be adapted to present a textual file to a user on a display of a computer system. Similarly, a multimedia application may be adapted to present a digital video and/or audio file to a user on a display and/or through a speaker of a computer system.

In presenting a digital file, an application may be adapted to receive input from a user. The input received from the user may be associated with the presentation of the digital file. For example, through an application, the user may adjust the playback position of an audio file or select a block of text in a textual file. In order to present such a digital file to a second user at a second computer system, the digital file may be transferred to the second computer system—e.g., via email, cloud storage, removable flash storage, etc. However, this method of transfer would not retain much of the input received at the first computer system from the first user.

As an alternative means of presentation of a digital file to a second user at a second computer system, the first and second computer systems may interface through remote desktop sharing. Through remote desktop sharing, the second computer system may present the digital file to the second user and, additionally, may present some interaction or input of the first user at the first computer system. However, the digital file would exist at the first computer system. Furthermore, the first and second computer systems would require an active connection to maintain the remote desktop sharing.

BRIEF DESCRIPTION OF THE DRAWINGS

The embodiments of the invention are illustrated by way of example and not by way of limitation in the figures of the accompanying drawings in which like references indicate similar elements. It should be noted that references to “an” or “one” embodiment of the invention in this disclosure are not necessarily to the same embodiment, and they mean at least one.

FIG. 1 is a block diagram illustrating a system for transferring a static object and associated context information from a source computer system to a target computer system, in accordance with various embodiments.

FIG. 2 is a block diagram illustrating a computer system that includes an application that is to present a static object with context information, in accordance with various embodiments.

FIG. 3 is a block diagram illustrating a computer system that is to facilitate transfer of a static object and context information between two separate computer systems, in accordance with various embodiments.

FIG. 4 is a block diagram illustrating transfer of a static object and associated context information between a source computer system and a target computer system, in accordance with various embodiments.

FIG. 5A is a block diagram illustrating one example of an application that is to present a static object with associated context information, in accordance with various embodiments.

FIG. 5B is a block diagram illustrating another example of an application that is to present a static object with associated context information, in accordance with various embodiments.

FIG. 6 is a sequence diagram illustrating one example of transfer of a static object and associated context information between separate computer systems through a manager computer system, in accordance with various embodiments.

FIG. 7 is a sequence diagram illustrating another example of transfer of a static object and associated context information between separate computer systems through a manager computer system, in accordance with various embodiments.

FIG. 8 is a flow diagram illustrating a method for generating a context package to transfer a static object and associated context information, in accordance with various embodiments.

FIG. 9 is a flow diagram illustrating a method for facilitating transfer of a context package between separate computer systems, in accordance with various embodiments.

FIG. 10 is a flow diagram illustrating a method for presenting a static object with associated context information based on a received context package, in accordance with various embodiments.

FIG. 11 is a flow diagram illustrating a method for collecting and transferring context data associated with a static object based on user interaction, in accordance with various embodiments.

DETAILED DESCRIPTION

In the following detailed description, reference is made to the accompanying drawings, which form a part hereof wherein like numerals designate like parts throughout, and in which is shown by way of illustration embodiments that may be practiced. It is to be understood that other embodiments may be utilized and structural or logical changes may be made without departing from the scope of the present disclosure. Therefore, the following detailed description is not to be taken in a limiting sense, and the scope of embodiments is defined by the appended claims and their equivalents.

Various operations may be described as multiple discrete actions or operations in turn, in a manner that is most helpful in understanding the claimed subject matter. However, the order of description should not be construed as to imply that these operations are necessarily order dependent. In particular, these operations may not be performed in the order of presentation. Operations described may be performed in a different order than the described embodiment. Various additional operations may be performed and/or described operations may be omitted in additional embodiments.

For the purposes of the present disclosure, the phrases “A or B” and “A and/or B” means (A), (B), or (A and B). For the purposes of the present disclosure, the phrase “A, B, and/or C” means (A), (B), (C), (A and B), (A and C), (B and C), or (A, B, and C).

The description may use the phrases “in an embodiment,” or “in embodiments,” which may each refer to one or more of the same or different embodiments. Furthermore, the terms “comprising,” “including,” “having,” and the like, as used with respect to embodiments of the present disclosure, are synonymous.

As used herein, the terms “module” and/or “logic” may refer to, be part of, or include an Application Specific Integrated Circuit (“ASIC”), an electronic circuit, a processor (shared, dedicated, or group), and/or memory (shared, dedicated, or group) that execute one or more software or firmware programs, a combinational logic circuit, and/or other suitable hardware components that provide the described functionality.

Beginning first with FIG. 1, a block diagram shows a system 100 for transferring a static object and associated context information from a source computer system 160 to a plurality of target computer systems 110 a-b, in accordance with various embodiments. The system 100 includes, but is not limited to, a source computer system 160, a plurality of target computer systems 110 a-b, a manager computer system 150, and a network 130. Each of the target computer systems 110 a-b may be any type of computer system adapted to receive data, such as a personal computer (e.g., a desktop computer, laptop computer, server, a tablet computer), a workstation, a handheld device, a web-enabled appliance, a gaming device, a mobile phone (e.g., a Smartphone), an eBook reader, or any computing device operable to communicate over the network 130. According to embodiments, the target computer systems 110 a-b are adapted to execute at least one application that is to present a static object. A static object may be any digital file, document, or similar resource—e.g., a text document, an image file, a uniform resource identifier (“URI”), a video file, an audio file, or essentially any other type of digital file suitable to be presented by an application. Accordingly, an application may be any set of instructions adapted to present a static object—e.g., a word processing application may present a static text document, a video application may present a Moving Picture Experts Group-4 (“MPEG-4”) static video file, a web browser may present a resource pointed to by a static URI, etc. The presentation of the static object by the application may include associated context data—e.g., the presentation of an MPEG-4 static video by a video application may include context data related to a presentation resolution, a position in the presentation time, etc. According to embodiments, the target computer systems 110 a-b may be adapted to receive a static object and associated context data from the manager computer system 150 and/or the source computer system 160.

The target computer systems 110 a-b may be configured for intersystem communication across a network 130. The network 130 may be a public, private, wired, wireless, or hybrid network, or a combination of different types of networks. The network 130 may be implemented as a local area network (“LAN”), a wide area network (“WAN”) such as the Internet, a corporate intranet, a metropolitan area network (“MAN”), a storage area network (“SAN”), a Fibre Channel (“FC”) network, a wireless cellular network (e.g., a cellular data network), or a combination thereof.

The network 130 may communicatively couple the target computer systems 110 a-b with a manager computer system 150. The manager computer system 150 may include any arrangement of hardware and software embodied in a computing device configured to provide access to one or more services to the target computer systems 110 a-b over the network 130. In various embodiments, the manager computer system 150 may include a server operating system, one or more software applications, and/or hardware (e.g., dedicated hardware) adapted to transmit a static object and/or associated context data to and receive requests for the same from the target computer systems 110 a-b over the network 130. Further, the components of the manager computer system 150 may allow the manager computer system 150 to receive that static object and/or associated context data from the source computer system 160.

In some embodiments, the manager computer system 150 may include a plurality of physical devices (e.g., hardware distributed in multiple physical machines). Thus, the manager computer system 150 may include two or more coupled computer devices that cooperatively operate. According to such embodiments, the plurality of physical devices may be hierarchically arranged and addressable as such. This hierarchical arrangement and addressing may extend to and incorporate each of the target computer systems 110 a-b. Thus, a target computer system 110 a may be addressable by the source computer system 160 through a hierarchical address, such as an Internet Protocol (“IP”) address or other similar address.

The manager computer system 150 may be communicatively coupled with a source computer system 160. The source computer system 160 may be connected with the manager computer system 150 through an interconnect 170, which may be a bus or a network (e.g., a network similar to the network 130). In the system 100, the manager computer system 150 may be implemented locally (e.g., integrated with the source computer system 160) or remotely (e.g., external from the source computer system 160). In embodiments in which the manager computer system 150 is locally implemented with the source computer system 160, the source computer system 160 may engage in peer-to-peer communication with the target computer systems 110 a-b. In another embodiment, the manager computer system 150 may communicate an address (e.g., an IP address) of the source computer system to the target computer systems 110 a-b so that the source computer system 160 may communicate directly with the target computer systems 110 a-b, such as through a peer-to-peer connection.

Similar to the target computer systems 110 a-b, the source computer system 160 may be any type of computer system adapted to transmit data, such as a personal computer (e.g., a desktop computer, laptop computer, server, or tablet computer), a workstation, a handheld device, a web-enabled appliance, a gaming device, a mobile phone (e.g., a Smartphone), an eBook reader, or any other similar computing device. According to embodiments, the source computer system 160 is adapted to execute at least one application that is to present a static object. The presentation of the static object by the application may include associated context data. According to embodiments, the source computer system 160 may be adapted to transmit a static object and associated context data to the manager computer system 150 and/or the target computer systems 110 a-b.

Turning now to FIG. 2, a block diagram illustrates a computer system 200 that includes an application 211 that is to present a static object 212 with context information 214, in accordance with various embodiments. The computer system 200 may be or may be included in the target computer systems 110 a-b and/or the source computer system 160 of FIG. 1. The computer system 200 includes at least one application 211 that is adapted to present a static object with context information 214.

The computer system 200 includes, but is not limited to, main memory 210, storage 217, processor 218, network interface 220, a user interface 222, a display 224, and/or a speaker 226. These components may be communicatively coupled through a bus 219. The bus 219 may be any subsystem adapted to transfer data within the computer system 200. The bus 219 may include a plurality of computer buses as well as additional circuitry adapted to transfer data.

To communicate data with a second computer system (not shown) (e.g., a source or target computer system, depending upon the embodiment, and/or a manager computer system), the computer system 200 includes a network interface 220. The network interface 220 may accept data across a network (not shown) from an external computer system to be processed by the computer system 200. Correspondingly, the network interface 220 may transmit data across a network. The network interface 220 may be implemented in hardware, software, or a combination of the two and may include, for example, components such as a network card, network access controller, or host bus adapter. The network interface 220 is communicatively coupled with the processor 218, which executes instructions for the computer system 200. In one embodiment, some or all of the instructions for the network interface 220 are executed by the processor 218.

As an additional means of receiving data, the computer system 200 may include a user interface 222 to receive input from a user. The user interface 222 may allow a user to interact with the computer system 200 through various means, according to different embodiments—e.g., the user interface 222 may be presented to a user on a display 224 as a graphical user interface or through a command line interface. To receive user input, the user interface 222 may be implemented in hardware, software, or a combination of the two and may include or may be communicatively coupled with one or more hardware devices suitable for user input (e.g., a keyboard, mouse, or touch screen). Further, some or all of the instructions for the user interface 222 may be executed by the processor 218.

The processor 218 may be any processor suitable to execute instructions, such as instructions from the main memory 210. Accordingly, the processor 218 may be, for example, a central processing unit (“CPU”), a microprocessor, or another similar processor. In some embodiments, the processor 218 includes a plurality of processors, such as a dedicated processor (e.g., a graphics processing unit), a network processor, or any processor suitable to execute operations of the computer system 200.

Coupled to the processor 218 is the main memory 210. The main memory 210 may offer both short-term and long-term storage and may in fact be divided into several units (including a unit located at the processor 218). The main memory 210 may be volatile, such as static random access memory (“SRAM”) and/or dynamic random access memory (“DRAM”), and may provide storage (at least temporarily) of computer-readable instructions, data structures, software applications, and other data for the computer system 200. Such data may be loaded from the storage 217. The main memory 210 may also include cache memory, such as a cache located at the processor 218. The main memory 210 may include, but is not limited to, instructions related to the elements 211-216 that are to be executed by the processor 218: an application 211 adapted to present a static object 212 with context information 214, a context stub module 215, and an operating system 216.

In various embodiments, the operating system 216 is configured to initiate the execution of the instructions, such as instructions provided by the application 211 or the context stub module 215. In particular, the operating system 216 may be adapted to serve as a platform for running the application 211. The operating system 216 may be adapted to perform other operations across the components of the computer system 200, including threading, resource management, data storage control, and other similar functionalities.

The operating system 216 may cause the processor 218 to execute instructions for the application 211. The application 211 may include code representing instructions configured to present a static object 212 by the computer system 200. According to embodiments, the application 211 may be, for example, a word processing application, a media application, a graphics program, an editing application, a web browser application, or essentially any other type of application adapted to present the static object 212. In various embodiments, the static object 212 may be, for example, a text document, an image file, a uniform resource identifier (“URI”), a video file, an audio file, or essentially any other type of digital file suitable to be presented by the application 211.

In some embodiments, the presentation of the static object 212 by the application 211 may be at the display 224. The display 224 may be any suitable device adapted to graphically present data to a user, such as a light-emitting diode (“LED”), an organic LED (“OLED”), a liquid crystal display (“LCD”), an LED-backlit LCD, a plasma display panel (“PDP”), a cathode ray tube (“CRT”), or other display technology. According to some embodiments, the presentation of the static object 212 by the application 211 may be at the speaker 226, which may be any electroacoustic transducer adapted to produce sound in response to an audio signal from the application 211. The application 211 may cause the static object 212 to be contemporaneously presented at both the display 224 and the speaker 226. The display 224 and the speaker 226 are illustrative devices for the presentation of the static object 212 by the application 211, and other methods of presentation of the static object 212 by the application 211 are contemplated herein.

In various embodiments, context information 214 may be associated with the presentation of the static object 212 by the application 211. Context information 214 may be received, such as through the network interface 220 and/or the user interface 222, and/or may be stored at the storage 217 of the computer system 200, such as a default setting for the application 211. Context information 214 may be essentially any information associated with the presentation of the static object 212 by the application 211. According to embodiments, context information 214 may include, for example, resolution information, a location associated with presentation of the static object 212 through the application 211 (e.g., the fifth paragraph of a text document, four minutes into an audio file, etc.), an object on a clipboard accessible by the application 211, a command history associated with the presentation of the static object 212 by the application 211 (e.g., one or more commands that the application 211 may undo and/or redo), a context of one or more objects included in the static object 212 (e.g., a status of an embedded image, a playback position of a video, etc.), a toolbar configuration, a presentation configuration (e.g., split screen, maximized, minimized, etc.), cookie information, session information, or other information associated with the presentation of the static object 212 by the application 211.

To re-create the presentation of the static object 212 with the context information 214 by the application 211, the application 211 may communicate with a context stub module 215. Where the computer system 200 is a source computer system, the context stub module 215 may be responsible for packaging and/or transmitting the static object 212 and the context information 214 (e.g., through the network interface 220). The context stub module 215 may receive a selection of a target computer device and/or manager computer device that is to receive the static object 212 and the context information 214 (e.g., as user input through user interface 222). The context stub module 215 may be adapted to generate a context package that is to include the static object 212 and the context information 214 without copying registers (not shown), or other memory. The context stub module 215 may then be adapted to transmit the generated context package.

Where the computer system 200 is a target computer system, the context stub module 215 may be responsible for receiving the static object 212 and the context information 214 and/or extracting the same from a context package. Accordingly, the context stub module 215 may communicate with the application 211 to re-create presentation of the static object 212 with associated context information 214 that is similar to the presentation at a source computer device. In embodiments, the context stub module 215 may receive a selection of a context package, a source computer device, and/or a manager computer system from which to receive the context package. The context stub module 215 may receive a context package through, for example, a push service or a pull service (e.g., the context module 215 may transmit a request for a context package).

With respect to FIG. 3, a block diagram is shown illustrating a manager computer system 300 that is to facilitate transfer of a context package 311 between two separate computer systems (not shown), in accordance with various embodiments. The manager computer system 300 may be or may be included in the manager computer system 150 of FIG. 1. The manager computer system 300 may include a main memory 310, storage 317, processor 318, bus or interconnect system 319, and/or network interface 320 similar to those elements described with respect to the computer system 200 of FIG. 2.

The main memory 310 may include, but is not limited to, instructions related to the elements 311-316 that are to be executed by the processor 318: a context package 311, a source list 312, a target list 314, a request manager 315, and an operating system 316. In various embodiments, the operating system 316 is configured to initiate the execution of the instructions, such as instructions provided by the request manager 315. The operating system 316 may be adapted to perform other operations across the components of the manager computer system 300, including threading, resource management, data storage control, and other similar functionality. The operating system 316 may cause the processor 318 to execute instructions.

The manager computer system 300 is adapted to facilitate the transfer of a static object and associated context information between source and target computer systems (not shown). In embodiments, the static object and associated context information may be received, from a source computer system, at the manager computer system 300 as a context package 311. In response, the manager computer system 300 may cache the context package 311 in, for example, the main memory 310 and/or store the context package 311 in the storage 317. The manager computer system 300 may be adapted to supply a target list 314 to the transmitting source computer system. Similarly, the manager computer system 300 may be adapted to supply a source list 312 to a target computer system. Additionally, the manager computer system 300 may be adapted to transmit the context package 311 to a target computer system.

According to some embodiments, the manager computer system may be adapted to manage reception and transmission of the context package 311 through a request manager 315. The request manager 315 may receive a selection of a target computer system (e.g., a target computer system included in the target list 314) from a source computer system that is to transmit the context package 311. Therefore, the request manager 315 may associate the context package 311 with an address for a target computer system, such as an IP address or similar hierarchical address. The request manager 315 may therefore cause the context package 311 to be transmitted to the addressed target machine.

In embodiments, the request manager 315 may receive a selection of a source computer system (e.g., a source computer system included in the source list 312) from a target computer system that is to receive the context package 311. Alternatively, the request manager 315 may receive a request for the context package 311 specifically. In response, the request manager 315 may transmit the context package 311 to the target computer system.

FIG. 4 illustrates a block diagram of a system 400 for transfer of a static object 415 and associated context settings 411 between a source computer system 405 and a target computer system 450, in accordance with various embodiments. The source computer system 405 may be or may be included in the source computer system 160, the target computer system 450 may be or may be included in one of the target computer systems 110 a-b, and the manager computer system 430 may be or may be included in the manager computer system 150, as illustrated in FIG. 1.

According to embodiments, the source computer system 405 may present a static object 415 through an application 410. The presentation of the static object 415 by the application 410 may be associated with a plurality of context settings 411 (collectively, context data or context information). In various embodiments, the source computer system 405 may include a source framework 420. The source framework 420 may be, for example, a platform, application, compiler, library, software tool set, application programming interface, and/or other resource that allows the source computer system 405 to transmit the static object 415 and associated context settings 411 to the target computer system 450.

The source framework 420 may allow communication between the application 410 and the source context stub 418. The source context stub 418 may access the application 410 through the source framework 420 to obtain the static object 415 and associated context settings 411. The source context stub 418 may subsequently generate a context package 425 that is to include the static object 415 and associated context settings 411. In various embodiments, the source context stub 418 may include an address for the destination of the context package 425, such as an address of the manager computer system 430 and/or the target computer system 450. In embodiments, the source context stub 418 may transmit the context package 425 to the manager computer system 430 through one or more resources provided by the source framework 420.

The manager computer system 430 may subsequently transmit the context package 425 to the target computer system 450. In embodiments, the manager computer system 430 may transmit the context package 425 according to an address associated with the context package 425 and/or in response to a request received from the target computer system 450. The target computer system 450 may include a target framework 460 that may allow communication between the manager computer system 430 and the target context stub 478. The target framework 460 may be, for example, a platform, application, complier, library, software tool set, application programming interface, and/or other resource that allows the target computer system 450 to receive the context package 425 and/or extract the contents therefrom. The target context stub 478 may interface with the manager computer system 430 through the target framework 460 to obtain the context package 425. For example, the target context stub 478 may be adapted to transmit a request for the context package 425 through a function provided by the target framework 460 and/or the target context stub 478 may be adapted to receive the context package 425 through a push service initiated by the manager computer system 430 through the target framework 460.

The target context stub 478 may subsequently extract the static object 475 and associated context settings 471 from the context package 425 at the target computer system 450. In various embodiments, the target framework 460 may facilitate communication between the target context stub 478 and the application 470. Accordingly, the target context stub 478 may launch the application 470 at the target computer system 450 via an interface provided by the target framework 460. The target context stub 478 may then cause the application 470 to present the extracted static object 475 with associated context settings 471. The presentation of the static object 475 with associated context settings 471 by the application 470 may be similar to, or may attempt to approximate, the presentation of the static object 415 and associated context settings 411 by the application 410 at the source computer system 405. In various embodiments, the target context stub 478 may add system-dependent context settings and/or may override one or more context settings 471 extracted from the context package 425 (e.g., a resolution setting may be adjusted).

In various embodiments, a computer system may function as both a source computer system 405 and a target computer system 450. Thus, the source context stub 418 and the target context stub 478 may be integrated and/or the source framework 420 may be integrated with the target framework 460. Accordingly, the functions of a context stub and/or framework may depend upon whether a computer system is to receive a context package 425 or transmit a context package 425. According to another embodiment, the manager computer system 430 may be omitted or integrated in another computer system so that the transmission of the context package 425 between the source computer system 405 and the target computer system 450 is through a direct transmission (e.g., a peer-to-peer connection).

With respect to FIG. 5A, a block diagram illustrates one example of an application 500 that is to present a static object 505 with associated context information 510-520, in accordance with various embodiments. In this exemplary embodiment, the application 500 may be a word processing application. The word processing application 500 may be adapted to present a textual static object 505 having a plurality of characters that may be editable by input to the application 500.

The word processing application 500 may include a plurality of context settings 510-520 associated with the presentation of the textual static object 505. For example, the application 500 may include a toolbar configuration context setting 510 that presents one or more tools for the manipulation of the textual static object 505 (e.g., cut, copy, paste, etc.). Additionally, the application 500 may include a clipboard object context setting 515 associated with the presentation of the static object 505. The clipboard object context setting 515 may be, for example, text, an image, or another object that may supplement or otherwise be included in the presentation of the textual static object 505 by the application 500. As illustrated, the application 500 may include a location context setting 520 associated with the presentation of the static object 505. The location context setting 520 may indicate a location (e.g., a page, paragraph, etc.) of the static object 505 that is presented by the application 500.

In various embodiments, other context settings may be associated with the presentation of the textual static object 505 by the word processing application 500. For example, a context setting may include a command executed on the textual static object 505 (e.g., a command that may be undone or redone by the application 500), a window setting associated with presentation of the textual static object 505 by the application 500 (e.g., full screen, split screen, minimized), an aspect ratio, or essentially any other context setting associated with the presentation by the application 500.

With respect to FIG. 5B, a block diagram illustrates another example of an application 550 that is to present a static object 555 with associated context settings 560-575, in accordance with various embodiments. In this exemplary embodiment, the application 550 may be a web browsing application. The web browsing application 550 may be adapted to present a resource (e.g., a web page) that is referenced by a URI static object 555.

The web browsing application 550 may include a plurality of context settings 560-575 associated with the presentation of the resource pointed to by the URI static object 555. For example, the application 550 may include a cookie context setting 560 that includes one or more cookies used to store stateful information associated with the presentation of the resource pointed to by the URI static object 555. Similarly, the application 550 may include a session context setting 565 that includes, for example, a session identification (“ID”) used to associate information with visitors to the resource pointed to by the URI static object 555. Additionally, the application 550 may include an object context setting 570 associated with the presentation of an object included in the resource pointed to by the URI static object 555, such as a status of an embedded video or image. Further, the application 550 may include a location context setting 575 associated with the presentation of the URI static object 555. The location context setting 575 may indicate a location (e.g., a section, tag location, etc.) of the presentation of the resource pointed to by the URI static object 555 by the application 550.

In various embodiments, other context settings may be associated with the presentation of the resource pointed to by the URI static object 555 by the web browsing application 550. For example, a context setting may include a toolbar configuration, a window setting associated with presentation of the resource pointed to by the URI static object 555 by the application 550 (e.g., full screen, split screen, minimized), an aspect ratio, or essentially any other context setting associated with the presentation by the application 550.

Turning to FIG. 6, a sequence diagram illustrates one example of transfer of a static object and associated context information between separate computer systems through a manager computer system, in accordance with various embodiments. The sequence 600 may be performed by the computer systems illustrated in FIG. 1. Accordingly, the target computer system 620 may be one of the target computer systems 110 a-b, the manager 616 may be the manager computer system 150, and/or the source computer system 605 may be the source computer system 160. While FIG. 6 illustrates a plurality of sequential operations, one of ordinary skill would understand that one or more operations of the sequence 600 may be transposed and/or performed contemporaneously.

To begin, a source computer system 605 may connect and/or register with a manager 616 over a network 615 (operation 652). According to embodiments, the source computer system 605 may connect and/or register through a source context stub 608 adapted to facilitate the transfer of a static object and associated context data. In response, the manager 616 may be adapted to return a list of target computer systems that may receive the static object and associated context data (operation 654).

A target computer system 620 additionally may connect and/or register with a manager 616 over a network 615 (operation 656). The target computer system 620 may connect and/or register through a target context stub 622 adapted to facilitate the reception of a static object and associated context data. In response, the manager 616 may be adapted to return a list to the target computer system 620 through the target context stub 622 (operation 658). In some embodiments, this list may include a list of source computer systems (e.g., the source computer system 605) available to transmit a static object and associated context data and/or a list of static objects and respective associated context data available to be transmitted. Because source computer systems may be target computer systems as well, this list may identify target computer systems on the network which are both source and target computer systems. Based on the connection and/or registration of the target computer system 620, the manager 616 may transmit an updated list of target computer systems to the source computer system 605 (operation 660).

A source application 606 may be adapted to transfer a static object and associated context data to the source context stub 608 (operation 662). In various embodiments, the source context stub 608 may receive the static object and associated context data in response to a request. For example, the source computer system 605 may receive a request to transfer the static object and associated context data from a user, and contemporaneously receive a selection of a target computer system included in a list received from the manager 616. Based on the transfer from the source application 606, the source context stub 608 may be adapted to transfer the static object and associated context data to the manager 616 (operation 664). In various embodiments, the source context stub 608 may include an identification of the target computer system 620 that is to receive the static object and associated context data.

Subsequently, the manager 616 may be adapted to transfer the static object and associated context data to the target computer system 620 (operation 668). In various embodiments, the manager 616 may be adapted to make this transfer as part of a push service between the manager 616 and the target computer system 620. This push service may be appropriate where, for example, the target computer system 620 is substantially perpetually connected with and/or available to the manager 616 over the network 615. According to embodiments, the static object and associated context data may be received at the target computer system 620 by a target context stub 622. The target context stub 622 may be adapted to cause a target application 624 to launch (operation 670). In so doing, the target context stub 622 may load the received static object and associated context data in an attempt to approximate the static object and associated context data at the source application 606.

In various embodiments, the connection between the source context stub 608 and the target context stub 622 may be direct through a peer-to-peer connection. Therefore, even where the source computer system 605 and/or the target computer system 620 receive lists of computer systems on the network 615 from the manager computer system 616, the actual transfer of a static object and associated context information from the source computer system 605 to the target computer system 620 may be direct.

FIG. 7 shows a sequence diagram illustrating another example of transfer of a static object and associated context information between separate computer systems through a manager computer system, in accordance with various embodiments. The sequence 700 may be performed by the computer systems illustrated in FIG. 1. Accordingly, the target computer system 720 may be one of the target computer systems 110 a-b, the manager 716 may be the manager computer system 150, and/or the source computer system 705 may be the source computer system 160. While FIG. 7 illustrates a plurality of sequential operations, one of ordinary skill would understand that one or more operations of the sequence 700 may be transposed and/or performed contemporaneously.

To begin, a source computer system 705 may connect and/or register with a manager 716 over a network 715 through functionality provided by a source context stub 708 (operation 752). Based on the connection and/or registration, the manager 716 may be adapted to return a list of target computer systems that may receive a static object and associated context data from the source computer system 705 (operation 754). Similarly, a target computer system 720 may connect and/or register with a manager 716 over the network 715 through functionality provided by a target context stub 722 (operation 756). Based on this connection and/or registration, the manager 716 may be adapted to return a list of source/target computer systems (e.g., a list of computer systems that may participate in the sharing of static object and associated context data) and/or static objects and respective associated context data to the target computer system 720 through the target context stub 722 (operation 758). Thereafter, the manager 716 may refresh the list of target computer systems for the source computer system 705 (operation 760).

A source application 706 may be adapted to transfer a static object and associated context data to the source context stub 708 (operation 762). Based on the transfer from the source application 706, the source context stub 708 may be adapted to transfer the static object and associated context data to the manager 716 (operation 764). In various embodiments, the source context stub 708 may include an identification (e.g., a hierarchal address) of the target computer system 720 that is to receive the static object and associated context data. According to embodiments, however, the target computer system 720 may be disconnected from the network 715 and, therefore, unavailable to receive the static object and associated context data (operation 768). Should the manager 716 be unable to transfer the static object and associated context data to the target computer system 720, the manager 716 may cache the transfer request (operation 770). When the target computer system 720 is again able to communicate over the network 715, the target computer system 720 may transmit a request to the manager 716 for the static object and associated context data through a target context stub 722 (operation 772). This pull service may be appropriate where, for example, the target computer system 720 may be intermittently connected with and/or available to the manager 716 over the network 715. Based on the request, the manager 716 may be adapted to transfer the static object and associated context data to the target computer system 720 through the target context stub 722 (operation 774). The target context stub 722 may be adapted to cause a target application 724 to launch with the received static object and associated context data in an attempt to approximate the static object and associated context data at the source application 706 (operation 776).

FIG. 8 illustrates a flow diagram of a method 800 for generating a context package to transfer a static object and associated context information, in accordance with various embodiments. The method 800 may be performed by a source computer system, such as the source computer system 160 of FIG. 1. While FIG. 8 illustrates a plurality of sequential operations, one of ordinary skill would understand that one or more operations of the method 800 may be transposed and/or performed contemporaneously.

At operation 805, the method 800 may include presenting a static object. The static object may be presented by an application at the source computer system. Operation 810 may include determining context information associated with the static object based on the presentation. The determining based on the presentation may include, for example, receiving input that affects the presentation and/or recording data associated with the static object. Subsequently, operation 815 may include generating a context package that includes the static object and the determined context information.

According to an embodiment, the method 800 may proceed to operation 840 for transmitting the context package. In such an embodiment, the context package may be transmitted directly to a target computer system, such as through a peer-to-peer transfer. In an alternative embodiment, some operations 820-835 may optionally occur before operation 840. The method 800 may include operation 820 for registering with a manager computer system that may be adapted to facilitate the transfer of the context package. Based on the registering, operation 825 may include processing a list of target computer systems that are adapted to receive the context package through the manager computer system. This list may be received from a manager computer system. The method 800 may then include operation 830 for selecting a target computer system based on the list of target computer systems. Correspondingly, operation 835 may include addressing the context package to the selected target computer system. Operation 835 may include associating a hierarchical address (e.g., an IP address) with the context package. The method 800 may proceed to operation 840 for transmitting the context package to the selected target computer system.

With respect to FIG. 9, a flow diagram illustrates a method 900 for facilitating transfer of a context package between separate computer systems, in accordance with various embodiments. The method 900 may be performed by a manager computer system, such as the manager computer system 150 of FIG. 1. While FIG. 9 illustrates a plurality of sequential operations, one of ordinary skill would understand that one or more operations of the method 900 may be transposed and/or performed contemporaneously.

According to an embodiment, the method 900 may include operation 930 for processing a context package from a source computer system. According to embodiments, this context package may be received from the source computer system. Although not necessary, the context package may identify a target computer system that is to receive the context package. The method 900 may then reach operation 940 for processing a request to transmit the context package to the target computer system. In one embodiment, this request may be received from the source computer system in association with the context package. In another embodiment, this request may be received from the target computer system as part of a pull service between the manager computer system and the target computer system. Based on the request, operation 945 may include transmitting the context package to the target computer system.

In various embodiments, the method 900 may include one or more optional operations 905-925. At operation 905, the method 900 may include processing a registration request received from a source computer system. This registration request may allow the manager computer system to register the source computer system, which may allow the manager computer system to identify the source computer system as a source of one or more context packages. Subsequently, operation 910 may include adding the source computer system to a list of source computer systems. Operation 915 may include processing a registration request received from a target computer system. This registration request may allow the manager computer system to register and/or identify the target computer system as adapted to receive one or more context packages. Operation 920 may include adding the target computer system to a list of target computer systems. So that the source computer system may identify a destination for the context package, operation 925 may include transmitting the list of target computer systems to the source computer system. The method 900 may reach operation 930, as described herein.

According to one embodiment, operation 945 for transmitting the context package to the target computer system may be delayed, such as where the target computer system is unavailable to the manager computer system (e.g., disconnected from a network). Therefore, the method 900 may include operation 935 for caching the context package. When the target computer system becomes available, the method 900 may reach operation 940, which may include processing the pull request received from the target computer system.

Turning to FIG. 10, a flow diagram illustrates a method 1000 for presenting a static object with associated context information based on a received context package, in accordance with various embodiments. The method 1000 may be performed by a target computer system, such as the target computer systems 110 a-b of FIG. 1. While FIG. 10 illustrates a plurality of sequential operations, one of ordinary skill would understand that one or more operations of the method 1000 may be transposed and/or performed contemporaneously.

In various embodiments, the method 1000 may include operation 1010 for processing a context package that includes a static object and associated context information. This context package may be received from, for example, a source computer system or a manager computer system. Based on the context package, an operation 1015 may include loading the context information included in the context package. Embodiments of operation 1015 may comprise launching an application adapted to present the static object, loading the context information into the application, and loading the static object. Operation 1025 may include presenting the static object based on the loaded context information. Accordingly, the static object may be presented by the target computer system such that the presentation approximates a remote presentation at a computer system that is the source of the context package. The context information may include a plurality of context settings, and not all of these context settings may be suitable for presentation at the target computer system. Therefore, various embodiments may include an optional operation 1020 for overriding a context setting included in the context information.

According to some embodiments, the context package may be transmitted in response to a request. Therefore, an optional operation 1005 may precede operation 1010. Operation 1005 may include transmitting a pull request for the context package. In one embodiment, this pull request may be transmitted to a manager computer system adapted to cache the context package in anticipation of the pull request. In another embodiment, this pull request may be transmitted to a computer system that is the source of the context package, such as where the target computer system is directly connected to the source computer system.

With reference to FIG. 11, a flow diagram shows a method 1100 for collecting and transferring context data associated with a static object based on user interaction, in accordance with various embodiments. The method 1100 may be performed by a source computer system, such as the source computer system 160 of FIG. 1. While FIG. 11 illustrates a plurality of sequential operations, one of ordinary skill would understand that one or more operations of the method 1100 may be transposed and/or performed contemporaneously.

The method 1100 may begin with operation 1105 for receiving user interaction associated with a static object. In embodiments, this user interaction may be received through an application adapted to present the static object to the user. This user interaction may include essentially any input received at the application during or contemporaneous with the presentation of the static object by the application. Based on the user interaction, operation 1110 may include collecting context data associated with the static object. The context data may include one or more context settings that are associated with or based on the received user interaction, either directly or indirectly—e.g., a direct user interaction may cause an object to be placed on a clipboard, whereas an indirect user interaction may cause a cookie to be stored.

The method 1100 may include operation 1120 for receiving a selection of a target computer system. In one embodiment, the source computer system may be adapted to communicate with one or more target computer systems, such as through a manager computer system. Therefore, the method 1100 may include an optional operation 1115 for receiving a list of target computer systems that each are adapted to present the static object. In such an embodiment, the operation 1120 for receiving the selection of the target computer system may be based on the received list of target computer systems. Subsequently, operation 1125 may include transferring the static object and the collected context data to the selected target computer system. According to the embodiment, this transfer may be direct (e.g., through a peer-to-peer communication) or may be indirect (e.g., through a manager computer system).

In various embodiments, example 1 may include a computer system for transferring context data associated with an electronic document, the system comprising: at least one processor; and at least one memory having processor-executable instructions that, in response to execution by the at least one processor, cause the computer system to: present a static object; determine context information associated with the static object based on the presentation of the static object; generate a context package that is to include the static object and the associated context information; and transmit the generated context package to an external computer system over a network for external presentation of the static object with the associated context information. Example 2 may include the computer system of example 1, wherein the static object is a text document and the context information includes a command executed on the text document that can be undone by an application adapted to present the text document, a clipboard object, a location within the text document, a toolbar configuration, or a window setting associated with presentation of the text document. Example 3 may include the computer system of example 1, wherein the static object is a uniform resource identifier (“URI”) and the context information includes a location within a page of the URI, a status of an embedded object in the page, a cookie associated with the page, session information associated with the page, and a toolbar configuration. Example 4 may include the computer system of any of examples 1-3, wherein the determination of the context information and the generation of the context package are made using a framework adapted for transmission of context packages. Example 5 may include the computer system of any of examples 1-3, wherein the external computer system to which the generated context package is to be transmitted is a target computer system adapted to present the static object with the associated context information and the transmission is to be a peer-to-peer connection. Example 6 may include the computer system of any of examples 1-3, wherein the external computer system to which the generated context package is to be transmitted is a manager computer system adapted to transmit the context package to a target computer system. Example 7 may include the computer system of example 6, wherein the instructions, in response to execution by the at least one processor, cause the computer system to:

process a list of target computer systems adapted to receive the context package, the list to be received from a manager computer system; select a target computer system based on the list of target computer systems; and hierarchically address the context package to the selected target computer system, so that the transmission includes a hierarchal address. Example 8 may include the computer system of example 6, wherein the instructions, in response to execution by the at least one processor, cause the computer system to: transmit a registration request to the manager computer system.

In various embodiments, 9 may be a computer system for migrating context information associated with an electronic document between separate computer systems, the system comprising: at least one processor; and at least one memory having processor-executable instructions that, in response to execution by the at least one processor, cause the computer system to: process a source context package, received from a source computer system, that is to include a static object and context information associated with the static object; process a target request to transmit the source context package to a target computer system; and transmit, based on the request, the source context package to the target computer system to support presentation of the static object with the associated context information. Example 10 may include the computer system of example 9, wherein the instructions, in response to execution by the at least one processor, further cause the computer system to: transmit, to the source computer system, a list of target computer systems adapted to receive context packages, including the target computer system. Example 11 may include the computer system of example 10, wherein the instructions, in response to execution by the at least one processor, further cause the computer system to: process a registration request from the target computer system; and add the target computer system to the list of target computer systems based on the received registration request. Example 12 may include the computer system of any of example 9-11, wherein the instructions, in response to execution by the at least one processor, cause the computer system to: transmit, to the target computer system, a list of source computer systems adapted to generate context packages for presentation of static objects, including the source computer system. Example 13 may include the computer system of example 12, wherein the instructions, in response to execution by the at least one processor, further cause the computer system to: process a registration request from the source computer system; and add the source computer system to the list of source computer systems based on the received registration request. Example 14 may include the computer system of any of example 9-11, wherein the target request is received from the target computer system, and further wherein the instructions, in response to execution by the at least one processor, cause the computer system to: cache the source context package received from the source computer system. Example 15 may include the computer system of any of example 9-11, wherein the target request is received from the source computer system and includes a hierarchical address associated with the target computer system.

In various embodiments, example 16 may be computer system for re-creating an electronic document with associated context data from a separate computer system, the system comprising: at least one processor; and at least one memory having processor-executable instructions that, in response to execution by the at least one processor, cause the computer system to: process a context package, received from an external computer system over a network, that is to include a static object and context information associated with the static object; load the context information from the context package; and present the static object based on the loaded context information. Example 17 may include the computer system of example 16, wherein the static object is a text document and the context information includes a command executed on the text document that can be undone by an application adapted to present the text document, a clipboard object, a location within the text document, a toolbar configuration, or a window setting associated with presentation of the text document. Example 18 may include the computer system of example 16, wherein the static object is a uniform resource identifier (“URI”) and the context information includes a location within a page of the URI, a status of an embedded object in the page, a cookie associated with the page, session information associated with the page, and a toolbar configuration. Example 19 may include the computer system of example 16, wherein the instructions, in response to execution by the at least one processor, cause the computer system to: override a context setting included in the context information. Example 20 may include the computer system of example 16, wherein the external computer system from which the generated context package is to be received is a source computer system adapted to present the static object with the associated context information, and further wherein the reception over the network is to be a peer-to-peer connection. Example 21 may include the computer system of any of examples 16-20, wherein the external computer system to from which the generated context package is to be received is a manager computer system adapted to receive the context package from a source computer system. Example 22 may include the computer system of any of examples 16-20, wherein the instructions, in response to execution by the at least one processor, cause the computer system to: transmit, to a manager computer system, a pull request to receive the context package from the manager computer system.

In various embodiments, example 23 may be a method to be performed by a computer system for transferring context data associated with a static object, the method comprising: receiving user interaction associated with the static object; collecting the context data associated with the static object based on the receiving of the user interaction; receiving a selection of a target computer system adapted to present the static object; and transferring the static object and the collected context data to the selected target computer system. Example 24 may include the method of example 23, wherein the transferring the static object and the collected context data to the selected target computer system comprises: sending the static object and the collected context data to a manager computer system adapted to send the static object and the collected context data to the target computer system. Example 25 may include the method of any of examples 23-24, wherein selection is based on a list of target computer systems, and the method further comprising: receiving the list of target computer systems.

In various embodiments, example 26 may be one or more non-transitory computer system-readable media comprising computer system-executable instructions, wherein the instructions, in response to execution by a computer system, cause the computer system to: present a static object; determine context information associated with the static object based on the presentation of the static object; generate a context package that is to include the static object and the associated context information; and transmit the generated context package to an external computer system over a network for external presentation of the static object with the associated context information. Example 27 may include the one or more non-transitory computer system-readable media of example 26, wherein the static object is a text document and the context information includes a command executed on the text document that can be undone by an application adapted to present the text document, a clipboard object, a location within the text document, a toolbar configuration, or a window setting associated with presentation of the text document. Example 28 may include the one or more non-transitory computer system-readable media of example 26, wherein the static object is a uniform resource identifier (“URI”) and the context information includes a location within a page of the URI, a status of an embedded object in the page, a cookie associated with the page, session information associated with the page, and a toolbar configuration. Example 29 may include the one or more non-transitory computer system-readable media of any of examples 26-28, wherein the determination of the context information and the generation of the context package are made using a framework adapted for transmission of context packages. Example 30 may include the one or more non-transitory computer system-readable media of any of examples 26-28, wherein the external computer system to which the generated context package is to be transmitted is a target computer system adapted to present the static object with the associated context information and the transmission is to be a peer-to-peer connection.

In various embodiments, example 31 may be a method to be performed by a computer system for migrating context information associated with an electronic document, the method comprising: receiving, from a source computer system, a source context package that is to include a static object and context information associated with the static object; receiving a target request to transmit the source context package to a target computer system; and transmitting, based on the target request, the source context package to the target computer system to support presentation of the static object with the associated context information. Example 32 may include the method of example 31, further comprising: transmitting, to the source computer system, a list of target computer systems adapted to receive context packages, including the target computer system. Example 33 may include the method of example 32, further comprising: receiving a registration request from the target computer system; and adding the target computer system to the list of target computer systems based on the received registration request. Example 34 may include the method of any of examples 31-33, further comprising: transmitting, to the target computer system, a list of source computer systems adapted to generate context packages for presentation of static objects, including the source computer system. Example 35 may include the method of example 34, further comprising: receiving a registration request from the source computer system; and adding the source computer system to the list of source computer systems based on the received registration request. Example 36 may include the method of any of examples 31-33, wherein the target request is received from the target computer system, and the method further comprising: caching the context package received from the source computer system.

In various embodiments, example 37 may be one or more non-transitory computer system-readable media comprising computer system-executable instructions, wherein the instructions, in response to execution by a computer system, cause the computer system to: process a context package, received from an external computer system over a network, that is to include a static object and context information associated with the static object; load the context information from the context package; and present the static object based on the loaded context information. Example 38 may include the one or more non-transitory computer system-readable media of example 37, wherein the instructions, in response to execution by the computer system, cause the computer system to: override a context setting included in the context information. Example 39 may include the one or more non-transitory computer system-readable media of any of examples 37-38, wherein the external computer system from which the generated context package is to be received is a source computer system adapted to present the static object with the associated context information or a manager computer system adapted to receive the context package from a source computer system. Example 40 may include the one or more non-transitory computer system-readable media of any of examples 37-38, wherein the instructions, in response to execution by the computer system, cause the computer system to: transmit, to a manager computer system, a pull request to receive the context package from the manager computer system.

Some portions of the preceding detailed description have been presented in terms of algorithms and symbolic representations of operations on data bits within a computer memory. These algorithmic descriptions and representations are the ways used by those skilled in the data processing arts to most effectively convey the substance of their work to others skilled in the art. An algorithm is here, and generally, conceived to be a self-consistent sequence of operations leading to a desired result. The operations are those requiring physical manipulations of physical quantities.

It should be borne in mind, however, that all of these and similar terms are to be associated with the appropriate physical quantities and are merely convenient labels applied to these quantities. Unless specifically stated otherwise as apparent from the above discussion, it is appreciated that throughout the description, discussions utilizing terms such as those set forth in the claims below refer to the action and processes of a computer system, or similar electronic computing device, that manipulates and transforms data represented as physical (electronic) quantities within the computer system's registers and memories into other data similarly represented as physical quantities within the computer system memories or registers or other such information storage, transmission, or display devices.

Embodiments of the invention also relate to an apparatus for performing the operations herein. Such a computer program is stored in a non-transitory computer-readable medium. A machine-readable medium includes any mechanism for storing information in a form readable by a machine (e.g., a computer). For example, a machine-readable (e.g., computer-readable) medium includes a machine- (e.g., a computer-) readable storage medium (e.g., read only memory (“ROM”), random access memory (“RAM”), magnetic disk storage media, optical storage media, flash memory devices).

The processes or methods depicted in the preceding figures can be performed by processing logic that comprises hardware (e.g., circuitry, dedicated logic, etc.), software (e.g., embodied on a non-transitory computer-readable medium), or a combination of both. Although the processes or methods are described above in terms of some sequential operations, it should be appreciated that some of the operations described can be performed in a different order. Moreover, some operations can be performed in parallel rather than sequentially.

Embodiments of the present invention are not described with reference to any particular programming language. It will be appreciated that a variety of programming languages can be used to implement the teachings of embodiments of the invention as described herein.

In the foregoing Specification, embodiments of the invention have been described with reference to specific exemplary embodiments thereof. It will be evident that various modifications can be made thereto without departing from the broader spirit and scope of the invention as set forth in the following claims. The Specification and drawings are, accordingly, to be regarded in an illustrative sense rather than a restrictive sense. 

What is claimed is:
 1. A computer system for transferring context data associated with an electronic document, the system comprising: at least one processor; and at least one memory having processor-executable instructions that, in response to execution by the at least one processor, cause the computer system to: present a static object; determine context information associated with the static object based on the presentation of the static object; generate a context package that is to include the static object and the associated context information; and transmit the generated context package to an external computer system over a network for external presentation of the static object with the associated context information.
 2. The computer system of claim 1, wherein the static object is a text document and the context information includes a command executed on the text document that can be undone by an application adapted to present the text document, a clipboard object, a location within the text document, a toolbar configuration, or a window setting associated with presentation of the text document.
 3. The computer system of claim 1, wherein the static object is a uniform resource identifier (“URI”) and the context information includes a location within a page of the URI, a context of an embedded object in the page, a cookie associated with the page, session information associated with the page, and a toolbar configuration.
 4. The computer system of claim 1, wherein the determination of the context information and the generation of the context package are made using a framework adapted for transmission of context packages.
 5. The computer system of claim 1, wherein the external computer system to which the generated context package is to be transmitted is a target computer system adapted to present the static object with the associated context information and the transmission is to be a peer-to-peer connection.
 6. The computer system of claim 1, wherein the external computer system to which the generated context package is to be transmitted is a manager computer system adapted to transmit the context package to a target computer system.
 7. The computer system of claim 6, wherein the instructions, in response to execution by the at least one processor, cause the computer system to: process a list of target computer systems adapted to receive the context package, the list to be received from the manager computer system; select the target computer system based on the list of target computer systems; and hierarchically address the context package to the selected target computer system, so that the transmission includes a hierarchal address.
 8. The computer system of claim 6, wherein the instructions, in response to execution by the at least one processor, cause the computer system to: transmit a registration request to the manager computer system.
 9. A computer system for migrating context information associated with an electronic document between separate computer systems, the system comprising: at least one processor; and at least one memory having processor-executable instructions that, in response to execution by the at least one processor, cause the computer system to: process a source context package, received from a source computer system, that is to include a static object and context information associated with the static object; process a target request to transmit the source context package to a target computer system; and transmit, based on the request, the source context package to the target computer system to support presentation of the static object with the associated context information.
 10. The computer system of claim 9, wherein the instructions, in response to execution by the at least one processor, further cause the computer system to: transmit, to the source computer system, a list of target computer systems adapted to receive context packages, including the target computer system.
 11. The computer system of claim 10, wherein the instructions, in response to execution by the at least one processor, further cause the computer system to: process a registration request from the target computer system; and add the target computer system to the list of target computer systems based on the received registration request.
 12. The computer system of claim 9, wherein the instructions, in response to execution by the at least one processor, cause the computer system to: transmit, to the target computer system, a list of computer systems associated with the re-creation of static objects with associated context information, including the source computer system.
 13. The computer system of claim 12, wherein the instructions, in response to execution by the at least one processor, further cause the computer system to: process a registration request from the source computer system; and add the source computer system to the list of source computer systems based on the received registration request.
 14. The computer system of claim 9, wherein the target request is received from the target computer system, and further wherein the instructions, in response to execution by the at least one processor, cause the computer system to: cache the source context package received from the source computer system.
 15. The computer system of claim 9, wherein the target request is received from the source computer system and includes a hierarchical address associated with the target computer system.
 16. A computer system for re-creating an electronic document with associated context data from a separate computer system, the system comprising: at least one processor; and at least one memory having processor-executable instructions that, in response to execution by the at least one processor, cause the computer system to: process a context package, received from an external computer system over a network, that is to include a static object and context information associated with the static object; load the context information from the context package; and present the static object based on the loaded context information.
 17. The computer system of claim 16, wherein the static object is a text document and the context information includes a command executed on the text document that can be undone by an application adapted to present the text document, a clipboard object, a location within the text document, a toolbar configuration, or a window setting associated with presentation of the text document.
 18. The computer system of claim 16, wherein the static object is a uniform resource identifier (“URI”) and the context information includes a location within a page of the URI, a context of an embedded object in the page, a cookie associated with the page, session information associated with the page, and a toolbar configuration.
 19. The computer system of claim 16, wherein the instructions, in response to execution by the at least one processor, cause the computer system to: override a context setting included in the context information.
 20. The computer system of claim 16, wherein the external computer system from which the generated context package is to be received is a source computer system adapted to present the static object with the associated context information, and further wherein the reception over the network is to be a peer-to-peer connection.
 21. The computer system of claim 16, wherein the external computer system from which the generated context package is to be received is a manager computer system adapted to receive the context package from a source computer system.
 22. The computer system of claim 21, wherein the instructions, in response to execution by the at least one processor, cause the computer system to: transmit, to the manager computer system, a pull request to receive the context package from the manager computer system.
 23. A method to be performed by a computer system for transferring context data associated with a static object, the method comprising: receiving user interaction associated with the static object; collecting the context data associated with the static object based on the receiving of the user interaction; receiving a selection of a target computer system adapted to present the static object; and transferring the static object and the collected context data to the selected target computer system.
 24. The method of claim 23, wherein the transferring the static object and the collected context data to the selected target computer system comprises: sending the static object and the collected context data to a manager computer system adapted to send the static object and the collected context data to the target computer system.
 25. The method of claim 23, wherein selection is based on a list of target computer systems, and the method further comprising: receiving the list of target computer systems. 